home *** CD-ROM | disk | FTP | other *** search
/ Visual Basic Controls / Visual Basic Controls.iso / vbcontrol / cellcont / data1.cab / VCDEMO_Files / cell.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1998-11-20  |  41.1 KB  |  1,728 lines
  1. // Machine generated IDispatch wrapper class(es) created by Microsoft Visual C++
  2.  
  3. // NOTE: Do not modify the contents of this file.  If this class is regenerated by
  4. //  Microsoft Visual C++, your modifications will be overwritten.
  5.  
  6.  
  7. #include "stdafx.h"
  8. #include "cell.h"
  9.  
  10. /////////////////////////////////////////////////////////////////////////////
  11. // CCell
  12.  
  13. IMPLEMENT_DYNCREATE(CCell, CWnd)
  14.  
  15. /////////////////////////////////////////////////////////////////////////////
  16. // CCell properties
  17.  
  18. long CCell::GetCols()
  19. {
  20.     long result;
  21.     GetProperty(0x1, VT_I4, (void*)&result);
  22.     return result;
  23. }
  24.  
  25. void CCell::SetCols(long propVal)
  26. {
  27.     SetProperty(0x1, VT_I4, propVal);
  28. }
  29.  
  30. BOOL CCell::GetBorder()
  31. {
  32.     BOOL result;
  33.     GetProperty(0x2, VT_BOOL, (void*)&result);
  34.     return result;
  35. }
  36.  
  37. void CCell::SetBorder(BOOL propVal)
  38. {
  39.     SetProperty(0x2, VT_BOOL, propVal);
  40. }
  41.  
  42. BOOL CCell::GetTopLabelVisible()
  43. {
  44.     BOOL result;
  45.     GetProperty(0x3, VT_BOOL, (void*)&result);
  46.     return result;
  47. }
  48.  
  49. void CCell::SetTopLabelVisible(BOOL propVal)
  50. {
  51.     SetProperty(0x3, VT_BOOL, propVal);
  52. }
  53.  
  54. BOOL CCell::GetSideLabelVisible()
  55. {
  56.     BOOL result;
  57.     GetProperty(0x4, VT_BOOL, (void*)&result);
  58.     return result;
  59. }
  60.  
  61. void CCell::SetSideLabelVisible(BOOL propVal)
  62. {
  63.     SetProperty(0x4, VT_BOOL, propVal);
  64. }
  65.  
  66. BOOL CCell::GetHScrollVisible()
  67. {
  68.     BOOL result;
  69.     GetProperty(0x5, VT_BOOL, (void*)&result);
  70.     return result;
  71. }
  72.  
  73. void CCell::SetHScrollVisible(BOOL propVal)
  74. {
  75.     SetProperty(0x5, VT_BOOL, propVal);
  76. }
  77.  
  78. BOOL CCell::GetVScrollVisible()
  79. {
  80.     BOOL result;
  81.     GetProperty(0x6, VT_BOOL, (void*)&result);
  82.     return result;
  83. }
  84.  
  85. void CCell::SetVScrollVisible(BOOL propVal)
  86. {
  87.     SetProperty(0x6, VT_BOOL, propVal);
  88. }
  89.  
  90. BOOL CCell::GetPageLabelVisible()
  91. {
  92.     BOOL result;
  93.     GetProperty(0x7, VT_BOOL, (void*)&result);
  94.     return result;
  95. }
  96.  
  97. void CCell::SetPageLabelVisible(BOOL propVal)
  98. {
  99.     SetProperty(0x7, VT_BOOL, propVal);
  100. }
  101.  
  102. long CCell::GetTopLabelHeight()
  103. {
  104.     long result;
  105.     GetProperty(0x8, VT_I4, (void*)&result);
  106.     return result;
  107. }
  108.  
  109. void CCell::SetTopLabelHeight(long propVal)
  110. {
  111.     SetProperty(0x8, VT_I4, propVal);
  112. }
  113.  
  114. long CCell::GetSideLabelWidth()
  115. {
  116.     long result;
  117.     GetProperty(0x9, VT_I4, (void*)&result);
  118.     return result;
  119. }
  120.  
  121. void CCell::SetSideLabelWidth(long propVal)
  122. {
  123.     SetProperty(0x9, VT_I4, propVal);
  124. }
  125.  
  126. BOOL CCell::GetRowSelectedMode()
  127. {
  128.     BOOL result;
  129.     GetProperty(0xa, VT_BOOL, (void*)&result);
  130.     return result;
  131. }
  132.  
  133. void CCell::SetRowSelectedMode(BOOL propVal)
  134. {
  135.     SetProperty(0xa, VT_BOOL, propVal);
  136. }
  137.  
  138. BOOL CCell::GetMultiSelectedMode()
  139. {
  140.     BOOL result;
  141.     GetProperty(0xb, VT_BOOL, (void*)&result);
  142.     return result;
  143. }
  144.  
  145. void CCell::SetMultiSelectedMode(BOOL propVal)
  146. {
  147.     SetProperty(0xb, VT_BOOL, propVal);
  148. }
  149.  
  150. BOOL CCell::GetDynamicEditArea()
  151. {
  152.     BOOL result;
  153.     GetProperty(0xc, VT_BOOL, (void*)&result);
  154.     return result;
  155. }
  156.  
  157. void CCell::SetDynamicEditArea(BOOL propVal)
  158. {
  159.     SetProperty(0xc, VT_BOOL, propVal);
  160. }
  161.  
  162. BOOL CCell::GetMultiColSizeMode()
  163. {
  164.     BOOL result;
  165.     GetProperty(0xd, VT_BOOL, (void*)&result);
  166.     return result;
  167. }
  168.  
  169. void CCell::SetMultiColSizeMode(BOOL propVal)
  170. {
  171.     SetProperty(0xd, VT_BOOL, propVal);
  172. }
  173.  
  174. BOOL CCell::GetMultiRowSizeMode()
  175. {
  176.     BOOL result;
  177.     GetProperty(0xe, VT_BOOL, (void*)&result);
  178.     return result;
  179. }
  180.  
  181. void CCell::SetMultiRowSizeMode(BOOL propVal)
  182. {
  183.     SetProperty(0xe, VT_BOOL, propVal);
  184. }
  185.  
  186. BOOL CCell::GetEnablePopMenu()
  187. {
  188.     BOOL result;
  189.     GetProperty(0xf, VT_BOOL, (void*)&result);
  190.     return result;
  191. }
  192.  
  193. void CCell::SetEnablePopMenu(BOOL propVal)
  194. {
  195.     SetProperty(0xf, VT_BOOL, propVal);
  196. }
  197.  
  198. BOOL CCell::GetCurrentTopLabelHint()
  199. {
  200.     BOOL result;
  201.     GetProperty(0x10, VT_BOOL, (void*)&result);
  202.     return result;
  203. }
  204.  
  205. void CCell::SetCurrentTopLabelHint(BOOL propVal)
  206. {
  207.     SetProperty(0x10, VT_BOOL, propVal);
  208. }
  209.  
  210. BOOL CCell::GetCurrentSideLabelHint()
  211. {
  212.     BOOL result;
  213.     GetProperty(0x11, VT_BOOL, (void*)&result);
  214.     return result;
  215. }
  216.  
  217. void CCell::SetCurrentSideLabelHint(BOOL propVal)
  218. {
  219.     SetProperty(0x11, VT_BOOL, propVal);
  220. }
  221.  
  222. BOOL CCell::GetResizeWhenPasteNeed()
  223. {
  224.     BOOL result;
  225.     GetProperty(0x12, VT_BOOL, (void*)&result);
  226.     return result;
  227. }
  228.  
  229. void CCell::SetResizeWhenPasteNeed(BOOL propVal)
  230. {
  231.     SetProperty(0x12, VT_BOOL, propVal);
  232. }
  233.  
  234. BOOL CCell::GetAllowSizeCell()
  235. {
  236.     BOOL result;
  237.     GetProperty(0x13, VT_BOOL, (void*)&result);
  238.     return result;
  239. }
  240.  
  241. void CCell::SetAllowSizeCell(BOOL propVal)
  242. {
  243.     SetProperty(0x13, VT_BOOL, propVal);
  244. }
  245.  
  246. BOOL CCell::GetGridReadOnly()
  247. {
  248.     BOOL result;
  249.     GetProperty(0x14, VT_BOOL, (void*)&result);
  250.     return result;
  251. }
  252.  
  253. void CCell::SetGridReadOnly(BOOL propVal)
  254. {
  255.     SetProperty(0x14, VT_BOOL, propVal);
  256. }
  257.  
  258. long CCell::GetRows()
  259. {
  260.     long result;
  261.     GetProperty(0x15, VT_I4, (void*)&result);
  262.     return result;
  263. }
  264.  
  265. void CCell::SetRows(long propVal)
  266. {
  267.     SetProperty(0x15, VT_I4, propVal);
  268. }
  269.  
  270. BOOL CCell::GetEnableUndo()
  271. {
  272.     BOOL result;
  273.     GetProperty(0x16, VT_BOOL, (void*)&result);
  274.     return result;
  275. }
  276.  
  277. void CCell::SetEnableUndo(BOOL propVal)
  278. {
  279.     SetProperty(0x16, VT_BOOL, propVal);
  280. }
  281.  
  282. BOOL CCell::GetAllowSizeRowInGrid()
  283. {
  284.     BOOL result;
  285.     GetProperty(0x17, VT_BOOL, (void*)&result);
  286.     return result;
  287. }
  288.  
  289. void CCell::SetAllowSizeRowInGrid(BOOL propVal)
  290. {
  291.     SetProperty(0x17, VT_BOOL, propVal);
  292. }
  293.  
  294. BOOL CCell::GetAllowSizeColInGrid()
  295. {
  296.     BOOL result;
  297.     GetProperty(0x18, VT_BOOL, (void*)&result);
  298.     return result;
  299. }
  300.  
  301. void CCell::SetAllowSizeColInGrid(BOOL propVal)
  302. {
  303.     SetProperty(0x18, VT_BOOL, propVal);
  304. }
  305.  
  306. /////////////////////////////////////////////////////////////////////////////
  307. // CCell operations
  308.  
  309. void CCell::DoPrint(BOOL showdlg)
  310. {
  311.     static BYTE parms[] =
  312.         VTS_BOOL;
  313.     InvokeHelper(0x19, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  314.          showdlg);
  315. }
  316.  
  317. void CCell::DoPrintPageSetup()
  318. {
  319.     InvokeHelper(0x1a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  320. }
  321.  
  322. void CCell::DoSetCellAlignment(long col, long row, long align)
  323. {
  324.     static BYTE parms[] =
  325.         VTS_I4 VTS_I4 VTS_I4;
  326.     InvokeHelper(0x1b, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  327.          col, row, align);
  328. }
  329.  
  330. void CCell::DoSetCellTextStyle(long col, long row, long style)
  331. {
  332.     static BYTE parms[] =
  333.         VTS_I4 VTS_I4 VTS_I4;
  334.     InvokeHelper(0x1c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  335.          col, row, style);
  336. }
  337.  
  338. void CCell::DoSetCell3DState(long col, long row, long state)
  339. {
  340.     static BYTE parms[] =
  341.         VTS_I4 VTS_I4 VTS_I4;
  342.     InvokeHelper(0x1d, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  343.          col, row, state);
  344. }
  345.  
  346. void CCell::DoSetCellData(long col, long row, const VARIANT& data)
  347. {
  348.     static BYTE parms[] =
  349.         VTS_I4 VTS_I4 VTS_VARIANT;
  350.     InvokeHelper(0x1e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  351.          col, row, &data);
  352. }
  353.  
  354. void CCell::DoSetCellNumberStyle(long col, long row, BOOL commas, BOOL percent, short decimal, short currencychar, double unit, short minus, BOOL mathstyle)
  355. {
  356.     static BYTE parms[] =
  357.         VTS_I4 VTS_I4 VTS_BOOL VTS_BOOL VTS_I2 VTS_I2 VTS_R8 VTS_I2 VTS_BOOL;
  358.     InvokeHelper(0x1f, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  359.          col, row, commas, percent, decimal, currencychar, unit, minus, mathstyle);
  360. }
  361.  
  362. void CCell::DoSetButtonCell(long col, long row, LPCTSTR text, LPCTSTR mesg)
  363. {
  364.     static BYTE parms[] =
  365.         VTS_I4 VTS_I4 VTS_BSTR VTS_BSTR;
  366.     InvokeHelper(0x20, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  367.          col, row, text, mesg);
  368. }
  369.  
  370. void CCell::DoSetRadioCell(long col, long row, LPCTSTR items)
  371. {
  372.     static BYTE parms[] =
  373.         VTS_I4 VTS_I4 VTS_BSTR;
  374.     InvokeHelper(0x21, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  375.          col, row, items);
  376. }
  377.  
  378. void CCell::DoSetDroplistCell(long col, long row, LPCTSTR items, BOOL hidetag, BOOL readonly)
  379. {
  380.     static BYTE parms[] =
  381.         VTS_I4 VTS_I4 VTS_BSTR VTS_BOOL VTS_BOOL;
  382.     InvokeHelper(0x22, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  383.          col, row, items, hidetag, readonly);
  384. }
  385.  
  386. void CCell::DoSetCheckboxCell(long col, long row, LPCTSTR text)
  387. {
  388.     static BYTE parms[] =
  389.         VTS_I4 VTS_I4 VTS_BSTR;
  390.     InvokeHelper(0x23, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  391.          col, row, text);
  392. }
  393.  
  394. void CCell::DoSetTextSpinCell(long col, long row, LPCTSTR items)
  395. {
  396.     static BYTE parms[] =
  397.         VTS_I4 VTS_I4 VTS_BSTR;
  398.     InvokeHelper(0x24, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  399.          col, row, items);
  400. }
  401.  
  402. void CCell::DoSetValueSpinCell(long col, long row, double min, double max, double step)
  403. {
  404.     static BYTE parms[] =
  405.         VTS_I4 VTS_I4 VTS_R8 VTS_R8 VTS_R8;
  406.     InvokeHelper(0x25, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  407.          col, row, min, max, step);
  408. }
  409.  
  410. void CCell::DoSetNormalCell(long col, long row)
  411. {
  412.     static BYTE parms[] =
  413.         VTS_I4 VTS_I4;
  414.     InvokeHelper(0x26, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  415.          col, row);
  416. }
  417.  
  418. void CCell::DoSetCellInputControlCase(long col, long row, short state)
  419. {
  420.     static BYTE parms[] =
  421.         VTS_I4 VTS_I4 VTS_I2;
  422.     InvokeHelper(0x27, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  423.          col, row, state);
  424. }
  425.  
  426. void CCell::DoSetCellInputControlMask(long col, long row, LPCTSTR mask)
  427. {
  428.     static BYTE parms[] =
  429.         VTS_I4 VTS_I4 VTS_BSTR;
  430.     InvokeHelper(0x28, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  431.          col, row, mask);
  432. }
  433.  
  434. void CCell::DoSetCellInputOnlyValue(long col, long row, BOOL maxflag, double max, BOOL minflag, double min)
  435. {
  436.     static BYTE parms[] =
  437.         VTS_I4 VTS_I4 VTS_BOOL VTS_R8 VTS_BOOL VTS_R8;
  438.     InvokeHelper(0x29, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  439.          col, row, maxflag, max, minflag, min);
  440. }
  441.  
  442. void CCell::DoSetCellColor(long col, long row, long foreclr, long backclr)
  443. {
  444.     static BYTE parms[] =
  445.         VTS_I4 VTS_I4 VTS_I4 VTS_I4;
  446.     InvokeHelper(0x2a, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  447.          col, row, foreclr, backclr);
  448. }
  449.  
  450. void CCell::DoInsertCol(long col, long count)
  451. {
  452.     static BYTE parms[] =
  453.         VTS_I4 VTS_I4;
  454.     InvokeHelper(0x2b, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  455.          col, count);
  456. }
  457.  
  458. void CCell::DoInsertRow(long row, long count)
  459. {
  460.     static BYTE parms[] =
  461.         VTS_I4 VTS_I4;
  462.     InvokeHelper(0x2c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  463.          row, count);
  464. }
  465.  
  466. void CCell::DoAppendCol(long count)
  467. {
  468.     static BYTE parms[] =
  469.         VTS_I4;
  470.     InvokeHelper(0x2d, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  471.          count);
  472. }
  473.  
  474. void CCell::DoAppendRow(long count)
  475. {
  476.     static BYTE parms[] =
  477.         VTS_I4;
  478.     InvokeHelper(0x2e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  479.          count);
  480. }
  481.  
  482. void CCell::DoRedrawAll()
  483. {
  484.     InvokeHelper(0x2f, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  485. }
  486.  
  487. void CCell::DoRedrawCell(long col, long row)
  488. {
  489.     static BYTE parms[] =
  490.         VTS_I4 VTS_I4;
  491.     InvokeHelper(0x30, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  492.          col, row);
  493. }
  494.  
  495. void CCell::DoRedrawRange(long startcol, long startrow, long endcol, long endrow)
  496. {
  497.     static BYTE parms[] =
  498.         VTS_I4 VTS_I4 VTS_I4 VTS_I4;
  499.     InvokeHelper(0x31, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  500.          startcol, startrow, endcol, endrow);
  501. }
  502.  
  503. void CCell::DoRedrawGrid()
  504. {
  505.     InvokeHelper(0x32, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  506. }
  507.  
  508. void CCell::DoRedrawTopLabel()
  509. {
  510.     InvokeHelper(0x33, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  511. }
  512.  
  513. void CCell::DoRedrawSideLabel()
  514. {
  515.     InvokeHelper(0x34, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  516. }
  517.  
  518. void CCell::DoRedrawHScroll()
  519. {
  520.     InvokeHelper(0x35, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  521. }
  522.  
  523. void CCell::DoRedrawVScroll()
  524. {
  525.     InvokeHelper(0x36, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  526. }
  527.  
  528. void CCell::DoRedrawPageLabel()
  529. {
  530.     InvokeHelper(0x37, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  531. }
  532.  
  533. void CCell::DoDeletePage(long index, long count)
  534. {
  535.     static BYTE parms[] =
  536.         VTS_I4 VTS_I4;
  537.     InvokeHelper(0x38, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  538.          index, count);
  539. }
  540.  
  541. void CCell::DoSetPageLabel(long index, LPCTSTR label)
  542. {
  543.     static BYTE parms[] =
  544.         VTS_I4 VTS_BSTR;
  545.     InvokeHelper(0x39, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  546.          index, label);
  547. }
  548.  
  549. void CCell::DoDeleteCol(long pos, long count)
  550. {
  551.     static BYTE parms[] =
  552.         VTS_I4 VTS_I4;
  553.     InvokeHelper(0x3a, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  554.          pos, count);
  555. }
  556.  
  557. void CCell::DoDeleteRow(long pos, long count)
  558. {
  559.     static BYTE parms[] =
  560.         VTS_I4 VTS_I4;
  561.     InvokeHelper(0x3b, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  562.          pos, count);
  563. }
  564.  
  565. void CCell::DoAppendPage(LPCTSTR label, long count)
  566. {
  567.     static BYTE parms[] =
  568.         VTS_BSTR VTS_I4;
  569.     InvokeHelper(0x3c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  570.          label, count);
  571. }
  572.  
  573. void CCell::DoSetCellFont(long col, long row, long size, long style, LPCTSTR name)
  574. {
  575.     static BYTE parms[] =
  576.         VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_BSTR;
  577.     InvokeHelper(0x3d, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  578.          col, row, size, style, name);
  579. }
  580.  
  581. long CCell::DoGetLeftCol()
  582. {
  583.     long result;
  584.     InvokeHelper(0x3e, DISPATCH_METHOD, VT_I4, (void*)&result, NULL);
  585.     return result;
  586. }
  587.  
  588. long CCell::DoGetTopRow()
  589. {
  590.     long result;
  591.     InvokeHelper(0x3f, DISPATCH_METHOD, VT_I4, (void*)&result, NULL);
  592.     return result;
  593. }
  594.  
  595. long CCell::DoGetCurrentCol()
  596. {
  597.     long result;
  598.     InvokeHelper(0x40, DISPATCH_METHOD, VT_I4, (void*)&result, NULL);
  599.     return result;
  600. }
  601.  
  602. long CCell::DoGetCurrentRow()
  603. {
  604.     long result;
  605.     InvokeHelper(0x41, DISPATCH_METHOD, VT_I4, (void*)&result, NULL);
  606.     return result;
  607. }
  608.  
  609. void CCell::DoSetDefaultRowHeight(long height)
  610. {
  611.     static BYTE parms[] =
  612.         VTS_I4;
  613.     InvokeHelper(0x42, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  614.          height);
  615. }
  616.  
  617. void CCell::DoSetDefaultColWidth(long width)
  618. {
  619.     static BYTE parms[] =
  620.         VTS_I4;
  621.     InvokeHelper(0x43, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  622.          width);
  623. }
  624.  
  625. void CCell::DoSetRowHeight(long row, long height)
  626. {
  627.     static BYTE parms[] =
  628.         VTS_I4 VTS_I4;
  629.     InvokeHelper(0x44, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  630.          row, height);
  631. }
  632.  
  633. void CCell::DoSetColWidth(long col, long width)
  634. {
  635.     static BYTE parms[] =
  636.         VTS_I4 VTS_I4;
  637.     InvokeHelper(0x45, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  638.          col, width);
  639. }
  640.  
  641. BOOL CCell::DoGetColWidth(long col, long* width)
  642. {
  643.     BOOL result;
  644.     static BYTE parms[] =
  645.         VTS_I4 VTS_PI4;
  646.     InvokeHelper(0x46, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  647.         col, width);
  648.     return result;
  649. }
  650.  
  651. BOOL CCell::DoGetRowHeight(long row, long* height)
  652. {
  653.     BOOL result;
  654.     static BYTE parms[] =
  655.         VTS_I4 VTS_PI4;
  656.     InvokeHelper(0x47, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  657.         row, height);
  658.     return result;
  659. }
  660.  
  661. void CCell::DoSortByCol(BOOL direction, long col)
  662. {
  663.     static BYTE parms[] =
  664.         VTS_BOOL VTS_I4;
  665.     InvokeHelper(0x48, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  666.          direction, col);
  667. }
  668.  
  669. void CCell::DoSetSortCol(long col, BOOL sort)
  670. {
  671.     static BYTE parms[] =
  672.         VTS_I4 VTS_BOOL;
  673.     InvokeHelper(0x49, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  674.          col, sort);
  675. }
  676.  
  677. void CCell::DoJoinCells(long startcol, long startrow, long endcol, long endrow)
  678. {
  679.     static BYTE parms[] =
  680.         VTS_I4 VTS_I4 VTS_I4 VTS_I4;
  681.     InvokeHelper(0x4a, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  682.          startcol, startrow, endcol, endrow);
  683. }
  684.  
  685. void CCell::DoUnJoinCells(long col, long row)
  686. {
  687.     static BYTE parms[] =
  688.         VTS_I4 VTS_I4;
  689.     InvokeHelper(0x4b, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  690.          col, row);
  691. }
  692.  
  693. void CCell::DoSetLeftCol(long col)
  694. {
  695.     static BYTE parms[] =
  696.         VTS_I4;
  697.     InvokeHelper(0x4c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  698.          col);
  699. }
  700.  
  701. void CCell::DoSetTopRow(long row)
  702. {
  703.     static BYTE parms[] =
  704.         VTS_I4;
  705.     InvokeHelper(0x4d, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  706.          row);
  707. }
  708.  
  709. void CCell::DoMoveToCell(long col, long row)
  710. {
  711.     static BYTE parms[] =
  712.         VTS_I4 VTS_I4;
  713.     InvokeHelper(0x4e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  714.          col, row);
  715. }
  716.  
  717. BOOL CCell::DoGetJoinRange(long col, long row, long* startcol, long* startrow, long* endcol, long* endrow)
  718. {
  719.     BOOL result;
  720.     static BYTE parms[] =
  721.         VTS_I4 VTS_I4 VTS_PI4 VTS_PI4 VTS_PI4 VTS_PI4;
  722.     InvokeHelper(0x4f, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  723.         col, row, startcol, startrow, endcol, endrow);
  724.     return result;
  725. }
  726.  
  727. void CCell::DoSetFormula(long col, long row, LPCTSTR text)
  728. {
  729.     static BYTE parms[] =
  730.         VTS_I4 VTS_I4 VTS_BSTR;
  731.     InvokeHelper(0x50, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  732.          col, row, text);
  733. }
  734.  
  735. void CCell::DoDelFormula(long col, long row)
  736. {
  737.     static BYTE parms[] =
  738.         VTS_I4 VTS_I4;
  739.     InvokeHelper(0x51, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  740.          col, row);
  741. }
  742.  
  743. void CCell::DoCalculateAll()
  744. {
  745.     InvokeHelper(0x52, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  746. }
  747.  
  748. BOOL CCell::IsFormulaCell(long col, long row)
  749. {
  750.     BOOL result;
  751.     static BYTE parms[] =
  752.         VTS_I4 VTS_I4;
  753.     InvokeHelper(0x53, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  754.         col, row);
  755.     return result;
  756. }
  757.  
  758. void CCell::DoSetRefChart(long col, long row, long startcol, long startrow, long endcol, long endrow)
  759. {
  760.     static BYTE parms[] =
  761.         VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4;
  762.     InvokeHelper(0x54, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  763.          col, row, startcol, startrow, endcol, endrow);
  764. }
  765.  
  766. void CCell::DoSetChart(long col, long row, long datacols, long datarows)
  767. {
  768.     static BYTE parms[] =
  769.         VTS_I4 VTS_I4 VTS_I4 VTS_I4;
  770.     InvokeHelper(0x55, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  771.          col, row, datacols, datarows);
  772. }
  773.  
  774. void CCell::DoSetChartRefData(long col, long row, long chartdatacol, long chartdatarow, long refcol, long refrow)
  775. {
  776.     static BYTE parms[] =
  777.         VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4;
  778.     InvokeHelper(0x56, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  779.          col, row, chartdatacol, chartdatarow, refcol, refrow);
  780. }
  781.  
  782. void CCell::DoSetChartData(long col, long row, long chartdatacol, long chartdatarow, const VARIANT& data)
  783. {
  784.     static BYTE parms[] =
  785.         VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_VARIANT;
  786.     InvokeHelper(0x57, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  787.          col, row, chartdatacol, chartdatarow, &data);
  788. }
  789.  
  790. void CCell::DoDelChart(long col, long row)
  791. {
  792.     static BYTE parms[] =
  793.         VTS_I4 VTS_I4;
  794.     InvokeHelper(0x58, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  795.          col, row);
  796. }
  797.  
  798. BOOL CCell::IsChartCell(long col, long row)
  799. {
  800.     BOOL result;
  801.     static BYTE parms[] =
  802.         VTS_I4 VTS_I4;
  803.     InvokeHelper(0x59, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  804.         col, row);
  805.     return result;
  806. }
  807.  
  808. void CCell::DoSetDefaultFont(long size, long style, LPCTSTR name)
  809. {
  810.     static BYTE parms[] =
  811.         VTS_I4 VTS_I4 VTS_BSTR;
  812.     InvokeHelper(0x5a, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  813.          size, style, name);
  814. }
  815.  
  816. void CCell::DoSelectCell(long col, long row)
  817. {
  818.     static BYTE parms[] =
  819.         VTS_I4 VTS_I4;
  820.     InvokeHelper(0x5b, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  821.          col, row);
  822. }
  823.  
  824. void CCell::DoSelectRange(long startcol, long startrow, long endcol, long endrow)
  825. {
  826.     static BYTE parms[] =
  827.         VTS_I4 VTS_I4 VTS_I4 VTS_I4;
  828.     InvokeHelper(0x5c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  829.          startcol, startrow, endcol, endrow);
  830. }
  831.  
  832. void CCell::DoClearSelection()
  833. {
  834.     InvokeHelper(0x5d, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  835. }
  836.  
  837. BOOL CCell::IsSelectedCell(long col, long row)
  838. {
  839.     BOOL result;
  840.     static BYTE parms[] =
  841.         VTS_I4 VTS_I4;
  842.     InvokeHelper(0x5e, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  843.         col, row);
  844.     return result;
  845. }
  846.  
  847. void CCell::DoCopyArea(long startcol, long startrow, long endcol, long endrow)
  848. {
  849.     static BYTE parms[] =
  850.         VTS_I4 VTS_I4 VTS_I4 VTS_I4;
  851.     InvokeHelper(0x5f, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  852.          startcol, startrow, endcol, endrow);
  853. }
  854.  
  855. void CCell::DoCopySelected()
  856. {
  857.     InvokeHelper(0x60, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  858. }
  859.  
  860. void CCell::DoCutSelected()
  861. {
  862.     InvokeHelper(0x61, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  863. }
  864.  
  865. void CCell::DoCutArea(long startcol, long startrow, long endcol, long endrow)
  866. {
  867.     static BYTE parms[] =
  868.         VTS_I4 VTS_I4 VTS_I4 VTS_I4;
  869.     InvokeHelper(0x62, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  870.          startcol, startrow, endcol, endrow);
  871. }
  872.  
  873. void CCell::DoPaste(long col, long row, BOOL samesize)
  874. {
  875.     static BYTE parms[] =
  876.         VTS_I4 VTS_I4 VTS_BOOL;
  877.     InvokeHelper(0x63, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  878.          col, row, samesize);
  879. }
  880.  
  881. BOOL CCell::DoGetFirstSelectedCell(long* col, long* row)
  882. {
  883.     BOOL result;
  884.     static BYTE parms[] =
  885.         VTS_PI4 VTS_PI4;
  886.     InvokeHelper(0x64, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  887.         col, row);
  888.     return result;
  889. }
  890.  
  891. BOOL CCell::DoGetNextSelectedCell(long* col, long* row)
  892. {
  893.     BOOL result;
  894.     static BYTE parms[] =
  895.         VTS_PI4 VTS_PI4;
  896.     InvokeHelper(0x65, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  897.         col, row);
  898.     return result;
  899. }
  900.  
  901. BOOL CCell::DoGetCellData(long col, long row, VARIANT* data)
  902. {
  903.     BOOL result;
  904.     static BYTE parms[] =
  905.         VTS_I4 VTS_I4 VTS_PVARIANT;
  906.     InvokeHelper(0x66, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  907.         col, row, data);
  908.     return result;
  909. }
  910.  
  911. void CCell::DoDrawHLine(long col1, long col2, long row, BOOL top, long color, long size)
  912. {
  913.     static BYTE parms[] =
  914.         VTS_I4 VTS_I4 VTS_I4 VTS_BOOL VTS_I4 VTS_I4;
  915.     InvokeHelper(0x67, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  916.          col1, col2, row, top, color, size);
  917. }
  918.  
  919. void CCell::DoDrawVLine(long row1, long row2, long col, BOOL left, long color, long size)
  920. {
  921.     static BYTE parms[] =
  922.         VTS_I4 VTS_I4 VTS_I4 VTS_BOOL VTS_I4 VTS_I4;
  923.     InvokeHelper(0x68, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  924.          row1, row2, col, left, color, size);
  925. }
  926.  
  927. void CCell::DoDrawXLine(long col1, long row, long col2, long row2, BOOL dir, long color, long size)
  928. {
  929.     static BYTE parms[] =
  930.         VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_BOOL VTS_I4 VTS_I4;
  931.     InvokeHelper(0x69, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  932.          col1, row, col2, row2, dir, color, size);
  933. }
  934.  
  935. void CCell::DoDelXLine(long col1, long row1, long col2, long row2)
  936. {
  937.     static BYTE parms[] =
  938.         VTS_I4 VTS_I4 VTS_I4 VTS_I4;
  939.     InvokeHelper(0x6a, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  940.          col1, row1, col2, row2);
  941. }
  942.  
  943. void CCell::DoDelUserFunction(LPCTSTR name)
  944. {
  945.     static BYTE parms[] =
  946.         VTS_BSTR;
  947.     InvokeHelper(0x6b, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  948.          name);
  949. }
  950.  
  951. void CCell::DoDelHLine(long col1, long col2, long row, BOOL top)
  952. {
  953.     static BYTE parms[] =
  954.         VTS_I4 VTS_I4 VTS_I4 VTS_BOOL;
  955.     InvokeHelper(0x6c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  956.          col1, col2, row, top);
  957. }
  958.  
  959. void CCell::DoDelVLine(long row1, long row2, long col, BOOL left)
  960. {
  961.     static BYTE parms[] =
  962.         VTS_I4 VTS_I4 VTS_I4 VTS_BOOL;
  963.     InvokeHelper(0x6d, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  964.          row1, row2, col, left);
  965. }
  966.  
  967. void CCell::DoSetCurrentPage(long pageno)
  968. {
  969.     static BYTE parms[] =
  970.         VTS_I4;
  971.     InvokeHelper(0x6e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  972.          pageno);
  973. }
  974.  
  975. long CCell::DoGetCurrentPage()
  976. {
  977.     long result;
  978.     InvokeHelper(0x6f, DISPATCH_METHOD, VT_I4, (void*)&result, NULL);
  979.     return result;
  980. }
  981.  
  982. void CCell::DoSetTotalPages(long pages)
  983. {
  984.     static BYTE parms[] =
  985.         VTS_I4;
  986.     InvokeHelper(0x70, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  987.          pages);
  988. }
  989.  
  990. long CCell::DoGetTotalPages()
  991. {
  992.     long result;
  993.     InvokeHelper(0x71, DISPATCH_METHOD, VT_I4, (void*)&result, NULL);
  994.     return result;
  995. }
  996.  
  997. void CCell::DoSetCanDragDrop(BOOL drag)
  998. {
  999.     static BYTE parms[] =
  1000.         VTS_BOOL;
  1001.     InvokeHelper(0x72, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1002.          drag);
  1003. }
  1004.  
  1005. void CCell::DoInsertPage(LPCTSTR label, long location, long count)
  1006. {
  1007.     static BYTE parms[] =
  1008.         VTS_BSTR VTS_I4 VTS_I4;
  1009.     InvokeHelper(0x73, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1010.          label, location, count);
  1011. }
  1012.  
  1013. void CCell::DoShowCurrentCell(BOOL focus, BOOL highlight)
  1014. {
  1015.     static BYTE parms[] =
  1016.         VTS_BOOL VTS_BOOL;
  1017.     InvokeHelper(0x74, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1018.          focus, highlight);
  1019. }
  1020.  
  1021. void CCell::DoSetEqualRowHeight(BOOL equal)
  1022. {
  1023.     static BYTE parms[] =
  1024.         VTS_BOOL;
  1025.     InvokeHelper(0x75, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1026.          equal);
  1027. }
  1028.  
  1029. void CCell::DoChartGuide(long col, long row, long col2, long row2)
  1030. {
  1031.     static BYTE parms[] =
  1032.         VTS_I4 VTS_I4 VTS_I4 VTS_I4;
  1033.     InvokeHelper(0x76, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1034.          col, row, col2, row2);
  1035. }
  1036.  
  1037. void CCell::DoInputFormula(long col, long row)
  1038. {
  1039.     static BYTE parms[] =
  1040.         VTS_I4 VTS_I4;
  1041.     InvokeHelper(0x77, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1042.          col, row);
  1043. }
  1044.  
  1045. BOOL CCell::DoFetchFuncParameter(short no, VARIANT* para)
  1046. {
  1047.     BOOL result;
  1048.     static BYTE parms[] =
  1049.         VTS_I2 VTS_PVARIANT;
  1050.     InvokeHelper(0x78, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  1051.         no, para);
  1052.     return result;
  1053. }
  1054.  
  1055. void CCell::DoLogin(long id, LPCTSTR passwd)
  1056. {
  1057.     static BYTE parms[] =
  1058.         VTS_I4 VTS_BSTR;
  1059.     InvokeHelper(0x79, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1060.          id, passwd);
  1061. }
  1062.  
  1063. BOOL CCell::DoCalculateExpr(LPCTSTR expr, short* rettype, VARIANT* exprresult)
  1064. {
  1065.     BOOL result;
  1066.     static BYTE parms[] =
  1067.         VTS_BSTR VTS_PI2 VTS_PVARIANT;
  1068.     InvokeHelper(0x7a, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  1069.         expr, rettype, exprresult);
  1070.     return result;
  1071. }
  1072.  
  1073. void CCell::DoSetCellValue(long col, long row, double value)
  1074. {
  1075.     static BYTE parms[] =
  1076.         VTS_I4 VTS_I4 VTS_R8;
  1077.     InvokeHelper(0x7b, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1078.          col, row, value);
  1079. }
  1080.  
  1081. void CCell::DoSetCellString(long col, long row, LPCTSTR string)
  1082. {
  1083.     static BYTE parms[] =
  1084.         VTS_I4 VTS_I4 VTS_BSTR;
  1085.     InvokeHelper(0x7c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1086.          col, row, string);
  1087. }
  1088.  
  1089. void CCell::DoSetChartGeneralData(long col, long row, short charttype, BOOL xaxisAttr, LPCTSTR title, LPCTSTR foot, LPCTSTR yaxisTitle)
  1090. {
  1091.     static BYTE parms[] =
  1092.         VTS_I4 VTS_I4 VTS_I2 VTS_BOOL VTS_BSTR VTS_BSTR VTS_BSTR;
  1093.     InvokeHelper(0x7d, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1094.          col, row, charttype, xaxisAttr, title, foot, yaxisTitle);
  1095. }
  1096.  
  1097. void CCell::DoRefreshChart(long col, long row)
  1098. {
  1099.     static BYTE parms[] =
  1100.         VTS_I4 VTS_I4;
  1101.     InvokeHelper(0x7e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1102.          col, row);
  1103. }
  1104.  
  1105. BOOL CCell::DoGetFormula(long col, long row, VARIANT* text)
  1106. {
  1107.     BOOL result;
  1108.     static BYTE parms[] =
  1109.         VTS_I4 VTS_I4 VTS_PVARIANT;
  1110.     InvokeHelper(0x7f, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  1111.         col, row, text);
  1112.     return result;
  1113. }
  1114.  
  1115. void CCell::DoDrawLineDlg()
  1116. {
  1117.     InvokeHelper(0x80, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  1118. }
  1119.  
  1120. void CCell::DoDrawLine(long startcol, long startrow, long endcol, long endrow, long type, long size, long color)
  1121. {
  1122.     static BYTE parms[] =
  1123.         VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4;
  1124.     InvokeHelper(0x81, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1125.          startcol, startrow, endcol, endrow, type, size, color);
  1126. }
  1127.  
  1128. void CCell::DoSetChartValueData(long col, long row, long chartcol, long chartrow, double value)
  1129. {
  1130.     static BYTE parms[] =
  1131.         VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_R8;
  1132.     InvokeHelper(0x82, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1133.          col, row, chartcol, chartrow, value);
  1134. }
  1135.  
  1136. void CCell::DoClearLine(long startcol, long startrow, long endcol, long endrow, long type)
  1137. {
  1138.     static BYTE parms[] =
  1139.         VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4;
  1140.     InvokeHelper(0x83, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1141.          startcol, startrow, endcol, endrow, type);
  1142. }
  1143.  
  1144. void CCell::DoSetBackGroundDlg()
  1145. {
  1146.     InvokeHelper(0x84, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  1147. }
  1148.  
  1149. void CCell::DoSetBackGround(long style)
  1150. {
  1151.     static BYTE parms[] =
  1152.         VTS_I4;
  1153.     InvokeHelper(0x85, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1154.          style);
  1155. }
  1156.  
  1157. void CCell::DoSetChartStringData(long col, long row, long chartcol, long chartrow, LPCTSTR text)
  1158. {
  1159.     static BYTE parms[] =
  1160.         VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_BSTR;
  1161.     InvokeHelper(0x86, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1162.          col, row, chartcol, chartrow, text);
  1163. }
  1164.  
  1165. BOOL CCell::DoGetColWidthVB(long col, VARIANT* width)
  1166. {
  1167.     BOOL result;
  1168.     static BYTE parms[] =
  1169.         VTS_I4 VTS_PVARIANT;
  1170.     InvokeHelper(0x87, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  1171.         col, width);
  1172.     return result;
  1173. }
  1174.  
  1175. BOOL CCell::DoGetRowHeightVB(long row, VARIANT* height)
  1176. {
  1177.     BOOL result;
  1178.     static BYTE parms[] =
  1179.         VTS_I4 VTS_PVARIANT;
  1180.     InvokeHelper(0x88, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  1181.         row, height);
  1182.     return result;
  1183. }
  1184.  
  1185. BOOL CCell::DoGetJoinRangeVB(long col, long row, VARIANT* startcol, VARIANT* startrow, VARIANT* endcol, VARIANT* endrow)
  1186. {
  1187.     BOOL result;
  1188.     static BYTE parms[] =
  1189.         VTS_I4 VTS_I4 VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT;
  1190.     InvokeHelper(0x89, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  1191.         col, row, startcol, startrow, endcol, endrow);
  1192.     return result;
  1193. }
  1194.  
  1195. BOOL CCell::DoCalculateExprVB(LPCTSTR expr, VARIANT* rttype, VARIANT* exprsult)
  1196. {
  1197.     BOOL result;
  1198.     static BYTE parms[] =
  1199.         VTS_BSTR VTS_PVARIANT VTS_PVARIANT;
  1200.     InvokeHelper(0x8a, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  1201.         expr, rttype, exprsult);
  1202.     return result;
  1203. }
  1204.  
  1205. BOOL CCell::DoGetFirstSelectedCellVB(VARIANT* col, VARIANT* row)
  1206. {
  1207.     BOOL result;
  1208.     static BYTE parms[] =
  1209.         VTS_PVARIANT VTS_PVARIANT;
  1210.     InvokeHelper(0x8b, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  1211.         col, row);
  1212.     return result;
  1213. }
  1214.  
  1215. void CCell::DoFind(BOOL withrepl)
  1216. {
  1217.     static BYTE parms[] =
  1218.         VTS_BOOL;
  1219.     InvokeHelper(0x8c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1220.          withrepl);
  1221. }
  1222.  
  1223. void CCell::DoReplace()
  1224. {
  1225.     InvokeHelper(0x8d, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  1226. }
  1227.  
  1228. void CCell::DoLocate()
  1229. {
  1230.     InvokeHelper(0x8e, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  1231. }
  1232.  
  1233. void CCell::DoShowFindDialog(BOOL show)
  1234. {
  1235.     static BYTE parms[] =
  1236.         VTS_BOOL;
  1237.     InvokeHelper(0x8f, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1238.          show);
  1239. }
  1240.  
  1241. void CCell::DoCloseFindDialog()
  1242. {
  1243.     InvokeHelper(0x90, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  1244. }
  1245.  
  1246. BOOL CCell::DoGetNextSelectedCellVB(VARIANT* col, VARIANT* row)
  1247. {
  1248.     BOOL result;
  1249.     static BYTE parms[] =
  1250.         VTS_PVARIANT VTS_PVARIANT;
  1251.     InvokeHelper(0x91, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  1252.         col, row);
  1253.     return result;
  1254. }
  1255.  
  1256. void CCell::DoSetDropGridCell(long col, long row, long areacol1, long arearow1, long areacol2, long arearow2, long pageno, BOOL onlycol, long validcol, BOOL hidetag, BOOL readonly)
  1257. {
  1258.     static BYTE parms[] =
  1259.         VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_BOOL VTS_I4 VTS_BOOL VTS_BOOL;
  1260.     InvokeHelper(0x92, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1261.          col, row, areacol1, arearow1, areacol2, arearow2, pageno, onlycol, validcol, hidetag, readonly);
  1262. }
  1263.  
  1264. BOOL CCell::DoOpenFileDbase(short dbasetype, LPCTSTR filename, VARIANT* tables)
  1265. {
  1266.     BOOL result;
  1267.     static BYTE parms[] =
  1268.         VTS_I2 VTS_BSTR VTS_PVARIANT;
  1269.     InvokeHelper(0x93, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  1270.         dbasetype, filename, tables);
  1271.     return result;
  1272. }
  1273.  
  1274. BOOL CCell::DoOpenODBCDbase(LPCTSTR connectstr, VARIANT* tables)
  1275. {
  1276.     BOOL result;
  1277.     static BYTE parms[] =
  1278.         VTS_BSTR VTS_PVARIANT;
  1279.     InvokeHelper(0x94, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  1280.         connectstr, tables);
  1281.     return result;
  1282. }
  1283.  
  1284. void CCell::DoCloseDbase()
  1285. {
  1286.     InvokeHelper(0x95, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  1287. }
  1288.  
  1289. void CCell::DoPrintPreview(BOOL allowPageset)
  1290. {
  1291.     static BYTE parms[] =
  1292.         VTS_BOOL;
  1293.     InvokeHelper(0x96, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1294.          allowPageset);
  1295. }
  1296.  
  1297. void CCell::DoSetPrintHead(LPCTSTR left, LPCTSTR mid, LPCTSTR right)
  1298. {
  1299.     static BYTE parms[] =
  1300.         VTS_BSTR VTS_BSTR VTS_BSTR;
  1301.     InvokeHelper(0x97, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1302.          left, mid, right);
  1303. }
  1304.  
  1305. void CCell::DoSetPrintFoot(LPCTSTR left, LPCTSTR mid, LPCTSTR right)
  1306. {
  1307.     static BYTE parms[] =
  1308.         VTS_BSTR VTS_BSTR VTS_BSTR;
  1309.     InvokeHelper(0x98, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1310.          left, mid, right);
  1311. }
  1312.  
  1313. void CCell::DoSetPrintLabel(BOOL collabel, BOOL rowlabel)
  1314. {
  1315.     static BYTE parms[] =
  1316.         VTS_BOOL VTS_BOOL;
  1317.     InvokeHelper(0x99, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1318.          collabel, rowlabel);
  1319. }
  1320.  
  1321. void CCell::DoSetPrintTitle(long col1, long row1, long col2, long row2, long Rows, long Cols)
  1322. {
  1323.     static BYTE parms[] =
  1324.         VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4;
  1325.     InvokeHelper(0x9a, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1326.          col1, row1, col2, row2, Rows, Cols);
  1327. }
  1328.  
  1329. void CCell::DoSetCellPicture(long col, long row, LPCTSTR picturefile, long style)
  1330. {
  1331.     static BYTE parms[] =
  1332.         VTS_I4 VTS_I4 VTS_BSTR VTS_I4;
  1333.     InvokeHelper(0x9b, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1334.          col, row, picturefile, style);
  1335. }
  1336.  
  1337. void CCell::DoSetButtonCellEx(long col, long row, LPCTSTR text, LPCTSTR runstring)
  1338. {
  1339.     static BYTE parms[] =
  1340.         VTS_I4 VTS_I4 VTS_BSTR VTS_BSTR;
  1341.     InvokeHelper(0x9c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1342.          col, row, text, runstring);
  1343. }
  1344.  
  1345. void CCell::DoCalculatePage(long pageno)
  1346. {
  1347.     static BYTE parms[] =
  1348.         VTS_I4;
  1349.     InvokeHelper(0x9d, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1350.          pageno);
  1351. }
  1352.  
  1353. void CCell::DoUndo()
  1354. {
  1355.     InvokeHelper(0x9e, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  1356. }
  1357.  
  1358. void CCell::DoRedo()
  1359. {
  1360.     InvokeHelper(0x9f, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  1361. }
  1362.  
  1363. void CCell::DoDiscardUndo()
  1364. {
  1365.     InvokeHelper(0xa0, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  1366. }
  1367.  
  1368. BOOL CCell::DoGetRedoState()
  1369. {
  1370.     BOOL result;
  1371.     InvokeHelper(0xa1, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
  1372.     return result;
  1373. }
  1374.  
  1375. BOOL CCell::DoGetUndoState()
  1376. {
  1377.     BOOL result;
  1378.     InvokeHelper(0xa2, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
  1379.     return result;
  1380. }
  1381.  
  1382. void CCell::DoSetMessageTitle(const VARIANT& title)
  1383. {
  1384.     static BYTE parms[] =
  1385.         VTS_VARIANT;
  1386.     InvokeHelper(0xa3, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1387.          &title);
  1388. }
  1389.  
  1390. void CCell::DoSetPageCellData(long col, long row, long page, const VARIANT& data)
  1391. {
  1392.     static BYTE parms[] =
  1393.         VTS_I4 VTS_I4 VTS_I4 VTS_VARIANT;
  1394.     InvokeHelper(0xa4, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1395.          col, row, page, &data);
  1396. }
  1397.  
  1398. BOOL CCell::DoGetPageCellData(long col, long row, long page, VARIANT* data)
  1399. {
  1400.     BOOL result;
  1401.     static BYTE parms[] =
  1402.         VTS_I4 VTS_I4 VTS_I4 VTS_PVARIANT;
  1403.     InvokeHelper(0xa5, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  1404.         col, row, page, data);
  1405.     return result;
  1406. }
  1407.  
  1408. void CCell::DoSetCellReadOnly(long col, long row, BOOL readonly)
  1409. {
  1410.     static BYTE parms[] =
  1411.         VTS_I4 VTS_I4 VTS_BOOL;
  1412.     InvokeHelper(0xa6, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1413.          col, row, readonly);
  1414. }
  1415.  
  1416. long CCell::DoOpenFile(LPCTSTR filename)
  1417. {
  1418.     long result;
  1419.     static BYTE parms[] =
  1420.         VTS_BSTR;
  1421.     InvokeHelper(0xa7, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
  1422.         filename);
  1423.     return result;
  1424. }
  1425.  
  1426. long CCell::DoSaveFile(LPCTSTR filename)
  1427. {
  1428.     long result;
  1429.     static BYTE parms[] =
  1430.         VTS_BSTR;
  1431.     InvokeHelper(0xa8, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
  1432.         filename);
  1433.     return result;
  1434. }
  1435.  
  1436. long CCell::DoGetColBestWidth(long col)
  1437. {
  1438.     long result;
  1439.     static BYTE parms[] =
  1440.         VTS_I4;
  1441.     InvokeHelper(0xa9, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
  1442.         col);
  1443.     return result;
  1444. }
  1445.  
  1446. long CCell::DoGetRowBestHeight(long row)
  1447. {
  1448.     long result;
  1449.     static BYTE parms[] =
  1450.         VTS_I4;
  1451.     InvokeHelper(0xaa, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
  1452.         row);
  1453.     return result;
  1454. }
  1455.  
  1456. BOOL CCell::DoDumpDbaseData(LPCTSTR sqlstring, long col, long row, long page, BOOL withfieldname, VARIANT* dumpcols, VARIANT* dumprows)
  1457. {
  1458.     BOOL result;
  1459.     static BYTE parms[] =
  1460.         VTS_BSTR VTS_I4 VTS_I4 VTS_I4 VTS_BOOL VTS_PVARIANT VTS_PVARIANT;
  1461.     InvokeHelper(0xab, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  1462.         sqlstring, col, row, page, withfieldname, dumpcols, dumprows);
  1463.     return result;
  1464. }
  1465.  
  1466. BOOL CCell::DoDumpDbaseTable(LPCTSTR tablename, long col, long row, long page, BOOL withfieldname, VARIANT* dumpcols, VARIANT* dumprows)
  1467. {
  1468.     BOOL result;
  1469.     static BYTE parms[] =
  1470.         VTS_BSTR VTS_I4 VTS_I4 VTS_I4 VTS_BOOL VTS_PVARIANT VTS_PVARIANT;
  1471.     InvokeHelper(0xac, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  1472.         tablename, col, row, page, withfieldname, dumpcols, dumprows);
  1473.     return result;
  1474. }
  1475.  
  1476. BOOL CCell::DoAddUserFunction(LPCTSTR functype, LPCTSTR funcname, short rttype, short paranum, short* paratype, LPCTSTR funchelp)
  1477. {
  1478.     BOOL result;
  1479.     static BYTE parms[] =
  1480.         VTS_BSTR VTS_BSTR VTS_I2 VTS_I2 VTS_PI2 VTS_BSTR;
  1481.     InvokeHelper(0xad, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  1482.         functype, funcname, rttype, paranum, paratype, funchelp);
  1483.     return result;
  1484. }
  1485.  
  1486. BOOL CCell::DoAddUserFunctionVB(LPCTSTR functype, LPCTSTR funcname, long rttype, long paranum, LPCTSTR paratype, LPCTSTR funchelp)
  1487. {
  1488.     BOOL result;
  1489.     static BYTE parms[] =
  1490.         VTS_BSTR VTS_BSTR VTS_I4 VTS_I4 VTS_BSTR VTS_BSTR;
  1491.     InvokeHelper(0xae, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  1492.         functype, funcname, rttype, paranum, paratype, funchelp);
  1493.     return result;
  1494. }
  1495.  
  1496. void CCell::DoSetPrintPara(float scale, short papersize, BOOL orientation)
  1497. {
  1498.     static BYTE parms[] =
  1499.         VTS_R4 VTS_I2 VTS_BOOL;
  1500.     InvokeHelper(0xaf, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1501.          scale, papersize, orientation);
  1502. }
  1503.  
  1504. BOOL CCell::DoOpenFileDbaseVfp(short dbasetype, LPCTSTR filename)
  1505. {
  1506.     BOOL result;
  1507.     static BYTE parms[] =
  1508.         VTS_I2 VTS_BSTR;
  1509.     InvokeHelper(0xb0, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  1510.         dbasetype, filename);
  1511.     return result;
  1512. }
  1513.  
  1514. BOOL CCell::DoDumpDbaseDataVfp(LPCTSTR sqlstring, long col, long row, long page, BOOL withfieldname)
  1515. {
  1516.     BOOL result;
  1517.     static BYTE parms[] =
  1518.         VTS_BSTR VTS_I4 VTS_I4 VTS_I4 VTS_BOOL;
  1519.     InvokeHelper(0xb1, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  1520.         sqlstring, col, row, page, withfieldname);
  1521.     return result;
  1522. }
  1523.  
  1524. BOOL CCell::DoCreateODBCDSN(LPCTSTR drivername, LPCTSTR description)
  1525. {
  1526.     BOOL result;
  1527.     static BYTE parms[] =
  1528.         VTS_BSTR VTS_BSTR;
  1529.     InvokeHelper(0xb2, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  1530.         drivername, description);
  1531.     return result;
  1532. }
  1533.  
  1534. BOOL CCell::DoRemoveODBCDSN(LPCTSTR dsnname)
  1535. {
  1536.     BOOL result;
  1537.     static BYTE parms[] =
  1538.         VTS_BSTR;
  1539.     InvokeHelper(0xb3, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  1540.         dsnname);
  1541.     return result;
  1542. }
  1543.  
  1544. BOOL CCell::DoOpenODBCDbaseVfp(LPCTSTR connectstr)
  1545. {
  1546.     BOOL result;
  1547.     static BYTE parms[] =
  1548.         VTS_BSTR;
  1549.     InvokeHelper(0xb4, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  1550.         connectstr);
  1551.     return result;
  1552. }
  1553.  
  1554. void CCell::DoSetColWidthEx(long col1, long col2, double width, short units)
  1555. {
  1556.     static BYTE parms[] =
  1557.         VTS_I4 VTS_I4 VTS_R8 VTS_I2;
  1558.     InvokeHelper(0xb5, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1559.          col1, col2, width, units);
  1560. }
  1561.  
  1562. void CCell::DoSetRowHeightEx(long row1, long row2, double height, short units)
  1563. {
  1564.     static BYTE parms[] =
  1565.         VTS_I4 VTS_I4 VTS_R8 VTS_I2;
  1566.     InvokeHelper(0xb6, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1567.          row1, row2, height, units);
  1568. }
  1569.  
  1570. void CCell::DoSetUnScrollRow(long row1, long row2)
  1571. {
  1572.     static BYTE parms[] =
  1573.         VTS_I4 VTS_I4;
  1574.     InvokeHelper(0xb7, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1575.          row1, row2);
  1576. }
  1577.  
  1578. void CCell::DoSetUnScrollCol(long col1, long col2)
  1579. {
  1580.     static BYTE parms[] =
  1581.         VTS_I4 VTS_I4;
  1582.     InvokeHelper(0xb8, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1583.          col1, col2);
  1584. }
  1585.  
  1586. BOOL CCell::DoGetSelectRange(VARIANT* col1, VARIANT* row1, VARIANT* col2, VARIANT* row2)
  1587. {
  1588.     BOOL result;
  1589.     static BYTE parms[] =
  1590.         VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT VTS_PVARIANT;
  1591.     InvokeHelper(0xb9, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  1592.         col1, row1, col2, row2);
  1593.     return result;
  1594. }
  1595.  
  1596. void CCell::DoResetContent()
  1597. {
  1598.     InvokeHelper(0xba, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  1599. }
  1600.  
  1601. void CCell::DoSetPrinter(LPCTSTR devname)
  1602. {
  1603.     static BYTE parms[] =
  1604.         VTS_BSTR;
  1605.     InvokeHelper(0xbb, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1606.          devname);
  1607. }
  1608.  
  1609. void CCell::DoSetPrintPara2(short scale, BOOL gridline, BOOL allcell)
  1610. {
  1611.     static BYTE parms[] =
  1612.         VTS_I2 VTS_BOOL VTS_BOOL;
  1613.     InvokeHelper(0xbc, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1614.          scale, gridline, allcell);
  1615. }
  1616.  
  1617. void CCell::DoSetCellPrintable(long col, long row, BOOL hide)
  1618. {
  1619.     static BYTE parms[] =
  1620.         VTS_I4 VTS_I4 VTS_BOOL;
  1621.     InvokeHelper(0xbd, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1622.          col, row, hide);
  1623. }
  1624.  
  1625. BOOL CCell::DoAppendPageFromFile(LPCTSTR filename, long startpage, long count)
  1626. {
  1627.     BOOL result;
  1628.     static BYTE parms[] =
  1629.         VTS_BSTR VTS_I4 VTS_I4;
  1630.     InvokeHelper(0xbe, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  1631.         filename, startpage, count);
  1632.     return result;
  1633. }
  1634.  
  1635. BOOL CCell::IsModified()
  1636. {
  1637.     BOOL result;
  1638.     InvokeHelper(0xbf, DISPATCH_METHOD, VT_BOOL, (void*)&result, NULL);
  1639.     return result;
  1640. }
  1641.  
  1642. void CCell::DoSetModifiedFlag(BOOL modified)
  1643. {
  1644.     static BYTE parms[] =
  1645.         VTS_BOOL;
  1646.     InvokeHelper(0xc0, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1647.          modified);
  1648. }
  1649.  
  1650. BOOL CCell::DoCopyPage(long dest, long source)
  1651. {
  1652.     BOOL result;
  1653.     static BYTE parms[] =
  1654.         VTS_I4 VTS_I4;
  1655.     InvokeHelper(0xc1, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  1656.         dest, source);
  1657.     return result;
  1658. }
  1659.  
  1660. void CCell::DoPrintPage(long page, BOOL showdlg)
  1661. {
  1662.     static BYTE parms[] =
  1663.         VTS_I4 VTS_BOOL;
  1664.     InvokeHelper(0xc2, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1665.          page, showdlg);
  1666. }
  1667.  
  1668. void CCell::DoPrintPreviewPage(long page, BOOL allowPageset)
  1669. {
  1670.     static BYTE parms[] =
  1671.         VTS_I4 VTS_BOOL;
  1672.     InvokeHelper(0xc3, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1673.          page, allowPageset);
  1674. }
  1675.  
  1676. void CCell::DoSetHintButtonCell(long col, long row, LPCTSTR text, LPCTSTR mesg, BOOL hide, BOOL canEdit)
  1677. {
  1678.     static BYTE parms[] =
  1679.         VTS_I4 VTS_I4 VTS_BSTR VTS_BSTR VTS_BOOL VTS_BOOL;
  1680.     InvokeHelper(0xc4, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
  1681.          col, row, text, mesg, hide, canEdit);
  1682. }
  1683.  
  1684. long CCell::DoSaveTextFile(LPCTSTR filename, long format)
  1685. {
  1686.     long result;
  1687.     static BYTE parms[] =
  1688.         VTS_BSTR VTS_I4;
  1689.     InvokeHelper(0xc5, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
  1690.         filename, format);
  1691.     return result;
  1692. }
  1693.  
  1694. long CCell::DoSaveHtmlFile(LPCTSTR filename)
  1695. {
  1696.     long result;
  1697.     static BYTE parms[] =
  1698.         VTS_BSTR;
  1699.     InvokeHelper(0xc6, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
  1700.         filename);
  1701.     return result;
  1702. }
  1703.  
  1704. long CCell::DoReadTextFile(LPCTSTR filename, long format)
  1705. {
  1706.     long result;
  1707.     static BYTE parms[] =
  1708.         VTS_BSTR VTS_I4;
  1709.     InvokeHelper(0xc7, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
  1710.         filename, format);
  1711.     return result;
  1712. }
  1713.  
  1714. BOOL CCell::DoAddUserFunctionEx(LPCTSTR functype, LPCTSTR name, short rttype, short paranum, short* paratype, short* defaultpara, LPCTSTR funchelpstring)
  1715. {
  1716.     BOOL result;
  1717.     static BYTE parms[] =
  1718.         VTS_BSTR VTS_BSTR VTS_I2 VTS_I2 VTS_PI2 VTS_PI2 VTS_BSTR;
  1719.     InvokeHelper(0xc8, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
  1720.         functype, name, rttype, paranum, paratype, defaultpara, funchelpstring);
  1721.     return result;
  1722. }
  1723.  
  1724. void CCell::AboutBox()
  1725. {
  1726.     InvokeHelper(0xfffffdd8, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
  1727. }
  1728.